// Copyright (C) 1999-2000 Id Software, Inc.
//

// every line of code that differs from the quake3:arena SDK
// is property of manfred nerurkar
// no commercial explotation allowed
// you are only allowed to use this code in navy seals: covert operations
// a quake3 arena modifiation
//
// fix the rotating door god damn

// defcon-x@ns-co.net

#include "g_local.h"

/*
===============================================================================

PUSHMOVE

===============================================================================
*/

void MatchTeam( gentity_t *teamLeader, int moverState, int time );

typedef struct {
    gentity_t	*ent;
    vec3_t	origin;
    vec3_t	angles;
    float	deltayaw;
} pushed_t;
pushed_t	pushed[MAX_GENTITIES], *pushed_p;


/*
============
G_TestEntityPosition

============
*/
gentity_t	*G_TestEntityPosition( gentity_t *ent ) {
    trace_t	tr;
    int		mask;

    if ( ent->clipmask ) {
        mask = ent->clipmask;
    } else {
        mask = MASK_SOLID;
    }
    if ( ent->client ) {
        trap_Trace( &tr, ent->client->ps.origin, ent->r.mins, ent->r.maxs, ent->client->ps.origin, ent->s.number, mask );
    } else {
        trap_Trace( &tr, ent->s.pos.trBase, ent->r.mins, ent->r.maxs, ent->s.pos.trBase, ent->s.number, mask );
    }

    if (tr.startsolid)
        return &g_entities[ tr.entityNum ];

    return NULL;
}


/*
==================
G_TryPushingEntity

Returns qfalse if the move is blocked
==================
*/
qboolean	G_TryPushingEntity( gentity_t *check, gentity_t *pusher, vec3_t move, vec3_t amove ) {
    vec3_t		forward, right, up;
    vec3_t		org, org2, move2;
    gentity_t	*block;

    // EF_MOVER_STOP will just stop when contacting another entity
    // instead of pushing it, but entities can still ride on top of it
    if ( ( pusher->s.eFlags & EF_MOVER_STOP ) &&
            check->s.groundEntityNum != pusher->s.number ) {
        return qfalse;
    }

    // save off the old position
    if (pushed_p > &pushed[MAX_GENTITIES]) {
        G_Error( "pushed_p > &pushed[MAX_GENTITIES]" );
    }
    pushed_p->ent = check;
    VectorCopy (check->s.pos.trBase, pushed_p->origin);
    VectorCopy (check->s.apos.trBase, pushed_p->angles);
    if ( check->client ) {
        pushed_p->deltayaw = check->client->ps.delta_angles[YAW];
        VectorCopy (check->client->ps.origin, pushed_p->origin);
    }
    pushed_p++;

    // we need this for pushing things later
    VectorSubtract (vec3_origin, amove, org);
    AngleVectors (org, forward, right, up);

    // try moving the contacted entity
    VectorAdd (check->s.pos.trBase, move, check->s.pos.trBase);
    if (check->client) {
        // make sure the client's view rotates when on a rotating mover
        check->client->ps.delta_angles[YAW] += ANGLE2SHORT(amove[YAW]);
    }

    // figure movement due to the pusher's amove
    VectorSubtract (check->s.pos.trBase, pusher->r.currentOrigin, org);
    org2[0] = DotProduct (org, forward);
    org2[1] = -DotProduct (org, right);
    org2[2] = DotProduct (org, up);
    VectorSubtract (org2, org, move2);
    VectorAdd (check->s.pos.trBase, move2, check->s.pos.trBase);
    if ( check->client ) {
        VectorAdd (check->client->ps.origin, move, check->client->ps.origin);
        VectorAdd (check->client->ps.origin, move2, check->client->ps.origin);
    }

    // may have pushed them off an edge
    if ( check->s.groundEntityNum != pusher->s.number ) {
        check->s.groundEntityNum = -1;
    }

    block = G_TestEntityPosition( check );
    if (!block) {
        // pushed ok
        if ( check->client ) {
            VectorCopy( check->client->ps.origin, check->r.currentOrigin );
        } else {
            VectorCopy( check->s.pos.trBase, check->r.currentOrigin );
        }
        trap_LinkEntity (check);
        return qtrue;
    }

    // if it is ok to leave in the old position, do it
    // this is only relevent for riding entities, not pushed
    // Sliding trapdoors can cause this.
    VectorCopy( (pushed_p-1)->origin, check->s.pos.trBase);
    if ( check->client ) {
        VectorCopy( (pushed_p-1)->origin, check->client->ps.origin);
    }
    VectorCopy( (pushed_p-1)->angles, check->s.apos.trBase );
    block = G_TestEntityPosition (check);
    if ( !block ) {
        check->s.groundEntityNum = -1;
        pushed_p--;
        return qtrue;
    }

    // blocked
    return qfalse;
}


/*
============
G_MoverPush

Objects need to be moved back on a failed push,
otherwise riders would continue to slide.
If qfalse is returned, *obstacle will be the blocking entity
============
*/
qboolean G_MoverPush( gentity_t *pusher, vec3_t move, vec3_t amove, gentity_t **obstacle ) {
    int			i, e;
    gentity_t	*check;
    vec3_t		mins, maxs;
    pushed_t	*p;
    int			entityList[MAX_GENTITIES];
    int			listedEntities;
    vec3_t		totalMins, totalMaxs;

    *obstacle = NULL;


    // mins/maxs are the bounds at the destination
    // totalMins / totalMaxs are the bounds for the entire move
    if ( pusher->r.currentAngles[0] || pusher->r.currentAngles[1] || pusher->r.currentAngles[2]
            || amove[0] || amove[1] || amove[2] ) {
        float		radius;

        radius = RadiusFromBounds( pusher->r.mins, pusher->r.maxs );
        for ( i = 0 ; i < 3 ; i++ ) {
            mins[i] = pusher->r.currentOrigin[i] + move[i] - radius;
            maxs[i] = pusher->r.currentOrigin[i] + move[i] + radius;
            totalMins[i] = mins[i] - move[i];
            totalMaxs[i] = maxs[i] - move[i];
        }
    } else {
        for (i=0 ; i<3 ; i++) {
            mins[i] = pusher->r.absmin[i] + move[i];
            maxs[i] = pusher->r.absmax[i] + move[i];
        }

        VectorCopy( pusher->r.absmin, totalMins );
        VectorCopy( pusher->r.absmax, totalMaxs );
        for (i=0 ; i<3 ; i++) {
            if ( move[i] > 0 ) {
                totalMaxs[i] += move[i];
            } else {
                totalMins[i] += move[i];
            }
        }
    }

    // unlink the pusher so we don't get it in the entityList
    trap_UnlinkEntity( pusher );

    listedEntities = trap_EntitiesInBox( totalMins, totalMaxs, entityList, MAX_GENTITIES );

    // move the pusher to it's final position
    VectorAdd( pusher->r.currentOrigin, move, pusher->r.currentOrigin );
    VectorAdd( pusher->r.currentAngles, amove, pusher->r.currentAngles );
    trap_LinkEntity( pusher );

    // see if any solid entities are inside the final position
    for ( e = 0 ; e < listedEntities ; e++ ) {
        check = &g_entities[ entityList[ e ] ];

        if ( check->s.eFlags & EF_DEAD )
            continue;

        // only push players
        if ( check->s.eType != ET_PLAYER || check->health < 0 ) {
            continue;
        }

        // if the entity is standing on the pusher, it will definitely be moved
        if ( check->s.groundEntityNum != pusher->s.number ) {
            // see if the ent needs to be tested
            if ( check->r.absmin[0] >= maxs[0]
                    || check->r.absmin[1] >= maxs[1]
                    || check->r.absmin[2] >= maxs[2]
                    || check->r.absmax[0] <= mins[0]
                    || check->r.absmax[1] <= mins[1]
                    || check->r.absmax[2] <= mins[2] ) {
                continue;
            }
            // see if the ent's bbox is inside the pusher's final position
            // this does allow a fast moving object to pass through a thin entity...
            if (!G_TestEntityPosition (check)) {
                continue;
            }
        }


        // rotatable doors do not push entities
        if( !(pusher->flags & FL_ROTATE) )
        {
            // the entity needs to be pushed
            if ( G_TryPushingEntity( check, pusher, move, amove ) ) {
                continue;
            }

            // the move was blocked an entity and we cannot move it so damage it!
            if ( pusher->damage ) {
                G_Damage( check, pusher, pusher, NULL, NULL, pusher->damage, 0, MOD_CRUSH );
            }
            // bobbing entities are instant-kill and never get blocked
            if ( pusher->s.pos.trType == TR_SINE || pusher->s.apos.trType == TR_SINE ) {
                G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
                continue;
            }
        }
        // save off the obstacle so we can call the block function (crush, etc)
        *obstacle = check;

        // move back any entities we already moved
        // go backwards, so if the same entity was pushed
        // twice, it goes back to the original position
        for ( p=pushed_p-1 ; p>=pushed ; p-- ) {
            VectorCopy (p->origin, p->ent->s.pos.trBase);
            VectorCopy (p->angles, p->ent->s.apos.trBase);
            if ( p->ent->client ) {
                p->ent->client->ps.delta_angles[YAW] = p->deltayaw;
                VectorCopy (p->origin, p->ent->client->ps.origin);
            }
            trap_LinkEntity (p->ent);
        }
        return qfalse;
    }
    return qtrue;
}


/*
=================
G_MoverTeam
=================
*/
void G_MoverTeam( gentity_t *ent ) {
    vec3_t		move, amove;
    gentity_t	*part, *obstacle;
    vec3_t		origin, angles;

    obstacle = NULL;

    // make sure all team slaves can move before commiting
    // any moves or calling any think functions
    // if the move is blocked, all moved objects will be backed out
    pushed_p = pushed;

    for (part = ent ; part ; part=part->teamchain) {
        // get current position
        BG_EvaluateTrajectory( &part->s.pos, level.time, origin );
        BG_EvaluateTrajectory( &part->s.apos, level.time, angles );
        VectorSubtract( origin, part->r.currentOrigin, move );
        VectorSubtract( angles, part->r.currentAngles, amove );

        if ( !G_MoverPush( part, move, amove, &obstacle ) ) {
            break;
        }
    }

    if (part) {
        // go back to the previous position
        for ( part = ent ; part ; part = part->teamchain ) {
            part->s.pos.trTime += level.time - level.previousTime;
            part->s.apos.trTime += level.time - level.previousTime;
            BG_EvaluateTrajectory( &part->s.pos, level.time, part->r.currentOrigin );
            BG_EvaluateTrajectory( &part->s.apos, level.time, part->r.currentAngles );
            trap_LinkEntity( part );
        }

        // if the pusher has a "blocked" function, call it
        if (ent->blocked) {
            ent->blocked( ent, obstacle );
        }
        return;
    }

    // the move succeeded
    // KnighthawK: rotating doors
    for ( part = ent ; part ; part = part->teamchain ) {
        // call the reached function if time is at or past end point

        // rotating doors
        if( !strcmp( ent->classname , "func_door_rotate" ) ){
            if( part->s.apos.trType == TR_LINEAR_STOP ) {
                if ( level.time >= part->s.apos.trTime + part->s.apos.trDuration ) {
                    if ( part->reached ) {
                        part->reached( part );
                    }
                }
            } // doors
        } else if ( part->s.pos.trType == TR_LINEAR_STOP ) {
            if ( level.time >= part->s.pos.trTime + part->s.pos.trDuration ) {
                if ( part->reached ) {
                    part->reached( part );
                }
            }
        }
    }
}

/*
================
G_RunMover

================
*/
void G_RunMover( gentity_t *ent ) {
    // if not a team captain, don't do anything, because
    // the captain will handle everything
    if ( ent->flags & FL_TEAMSLAVE ) {
        return;
    }

    // if stationary at one of the positions, don't move anything
    if ( ent->s.pos.trType != TR_STATIONARY || ent->s.apos.trType != TR_STATIONARY ) {
        G_MoverTeam( ent );
    }

    // check think function
    G_RunThink( ent );
}

/*
============================================================================

GENERAL MOVERS

Doors, plats, and buttons are all binary (two position) movers
Pos1 is "at rest", pos2 is "activated"
============================================================================
*/
/*
===============
SetMoverState
===============
*/
void SetMoverState( gentity_t *ent, moverState_t moverState, int time ) {
    vec3_t			delta;
    float			f;

    ent->moverState = moverState;
    ent->s.pos.trTime = time;

    // rotatable doors
    if( ent->flags & FL_ROTATE )
    {
        ent->s.apos.trTime = time;

        switch( moverState ) {
        case MOVER_POS1:
            VectorCopy( ent->s.angles, ent->s.apos.trBase );
            ent->s.apos.trType = TR_STATIONARY;
            break;
        case MOVER_POS2:
            VectorCopy( ent->s.angles2, ent->s.apos.trBase );
            ent->s.apos.trType = TR_STATIONARY;
            break;
        case MOVER_1TO2:
            VectorCopy( ent->s.angles, ent->s.apos.trBase ) ;
            VectorSubtract( ent->s.angles2, ent->s.angles, delta );
            f = 1000.0 / ent->s.apos.trDuration;
            VectorScale( delta, f, ent->s.apos.trDelta );
            ent->s.apos.trType = TR_LINEAR_STOP;
            break;
        case MOVER_2TO1:
            VectorCopy( ent->s.angles2, ent->s.apos.trBase ) ;
            VectorSubtract( ent->s.angles, ent->s.angles2, delta );
            f = 1000.0 / ent->s.apos.trDuration;
            VectorScale( delta, f, ent->s.apos.trDelta );
            ent->s.apos.trType = TR_LINEAR_STOP;
            break;
        case MOVER_STOP_1TO2:
            VectorCopy( ent->r.currentAngles , ent->s.apos.trBase ) ;
            VectorSubtract( ent->s.angles2, ent->r.currentAngles, delta );
            f = 1000.0 / ent->s.apos.trDuration;
            VectorScale( delta, f, ent->s.apos.trDelta );
            ent->moverState = MOVER_1TO2;
            ent->s.apos.trType = TR_LINEAR_STOP;
            break;
        case MOVER_STOP_2TO1:
            VectorCopy( ent->r.currentAngles , ent->s.apos.trBase ) ;
            VectorSubtract( ent->s.angles, ent->r.currentAngles, delta );
            f = 1000.0 / ent->s.apos.trDuration;
            VectorScale( delta, f, ent->s.apos.trDelta );
            ent->moverState = MOVER_2TO1;
            ent->s.apos.trType = TR_LINEAR_STOP;
            break;
        }
        BG_EvaluateTrajectory( &ent->s.apos, time, ent->r.currentAngles );

    }


    switch( moverState ) {
    case MOVER_POS1:
        VectorCopy( ent->pos1, ent->s.pos.trBase );
        ent->s.pos.trType = TR_STATIONARY;
        break;
    case MOVER_POS2:
        VectorCopy( ent->pos2, ent->s.pos.trBase );
        ent->s.pos.trType = TR_STATIONARY;
        break;
    case MOVER_1TO2:
        VectorCopy( ent->pos1, ent->s.pos.trBase );
        VectorSubtract( ent->pos2, ent->pos1, delta );
        f = 1000.0 / ent->s.pos.trDuration;
        VectorScale( delta, f, ent->s.pos.trDelta );
        ent->s.pos.trType = TR_LINEAR_STOP;
        break;
    case MOVER_2TO1:
        VectorCopy( ent->pos2, ent->s.pos.trBase );
        VectorSubtract( ent->pos1, ent->pos2, delta );
        f = 1000.0 / ent->s.pos.trDuration;
        VectorScale( delta, f, ent->s.pos.trDelta );
        ent->s.pos.trType = TR_LINEAR_STOP;
        break;

    case MOVER_STOP_1TO2:
        VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
        VectorSubtract( ent->pos2, ent->r.currentOrigin, delta );
        f = 1000.0 / ent->s.pos.trDuration;
        VectorScale( delta, f, ent->s.pos.trDelta );
        ent->moverState = MOVER_1TO2;
        ent->s.pos.trType = TR_LINEAR_STOP;
        break;
    case MOVER_STOP_2TO1:
        VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
        VectorSubtract( ent->pos1, ent->r.currentOrigin, delta );
        f = 1000.0 / ent->s.pos.trDuration;
        VectorScale( delta, f, ent->s.pos.trDelta );
        ent->moverState = MOVER_2TO1;
        ent->s.pos.trType = TR_LINEAR_STOP;
        break;
    }
    BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->r.currentOrigin );
    trap_LinkEntity( ent );
}



/*
================
MatchTeam

All entities in a mover team will move from pos1 to pos2
in the same amount of time
================
*/
void MatchTeam( gentity_t *teamLeader, int moverState, int time ) {
    gentity_t		*slave;

    for ( slave = teamLeader ; slave ; slave = slave->teamchain ) {
        SetMoverState( slave, moverState, time );
    }
}



/*
================
ReturnToPos1
================
*/
void ReturnToPos1( gentity_t *ent ) {
    MatchTeam( ent, MOVER_2TO1, level.time );

    // looping sound
    ent->s.loopSound = ent->soundLoop;

    // starting sound
    if ( ent->sound2to1 ) {
        G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
    }
}


/*
================
Reached_BinaryMover
================
*/
void Reached_BinaryMover( gentity_t *ent ) {

    // stop the looping sound
    ent->s.loopSound = ent->soundLoop;

    // toggle the open state of doors
    if (strcmp(ent->classname, "func_door")) {
        ent->bot_chattime = !ent->bot_chattime;
    }

    if ( ent->moverState == MOVER_1TO2 ||
            ent->moverState == MOVER_STOP_1TO2 ) {
        // reached pos2
        SetMoverState( ent, MOVER_POS2, level.time );

        // play sound
        if ( ent->soundPos2 ) {

            if ( ent->activator && ent->activator->client && ent->activator->client->pers.nsPC.stealth < 4 )
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->soundPos2 );
        }

        // return to pos1 after a delay
        ent->think = ReturnToPos1;
        if( ent->wait != -1 ) // KnighthawK rotating doors: dont go back if this is set
            ent->nextthink = level.time + ent->wait;

        // fire targets
        if ( !ent->activator ) {
            ent->activator = ent;
        }
        G_UseTargets( ent, ent->activator );
    } else if ( ent->moverState == MOVER_2TO1 ||
                ent->moverState == MOVER_STOP_2TO1 ) {
        // reached pos1
        SetMoverState( ent, MOVER_POS1, level.time );

        // play sound
        if ( ent->soundPos1 ) {
            if ( ent->activator && ent->activator->client && ent->activator->client->pers.nsPC.stealth < 4 )
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->soundPos1 );
        }

        // close areaportals
        if ( ent->teammaster == ent || !ent->teammaster ) {
            trap_AdjustAreaPortalState( ent, qfalse );
        }
    } else {
        G_Error( "Reached_BinaryMover: bad moverState" );
    }
}

/*
================
Use_BinaryMover
================
*/
void Use_BinaryMover( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
    int		total;
    int		partial;

    // only the master should be used
    if ( ent->flags & FL_TEAMSLAVE ) {
        Use_BinaryMover( ent->teammaster, other, activator );
        return;
    }

    ent->activator = activator;

    if ( ent->moverState == MOVER_STOP_1TO2 ||
            ent->moverState == MOVER_STOP_2TO1 ) {
        // start moving 50 msec later, becase if this was player
        // triggered, level.time hasn't been advanced yet
        MatchTeam( ent, ent->moverState , level.time );

        // looping sound
        ent->s.loopSound = ent->soundLoop;
        return;
    }


    if ( ent->moverState == MOVER_POS1 ) {
        // start moving 50 msec later, becase if this was player
        // triggered, level.time hasn't been advanced yet
        MatchTeam( ent, MOVER_1TO2, level.time + 50 );

        // starting sound
        if ( ent->sound1to2 ) {
            if ( ent->elevator_index >= 0)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2 );
            else if ( other->client && other->client->ps.stats[STAT_STEALTH] < 4)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2 );
        }

        // looping sound
        ent->s.loopSound = ent->soundLoop;

        // open areaportal
        if ( ent->teammaster == ent || !ent->teammaster ) {
            trap_AdjustAreaPortalState( ent, qtrue );
        }
        return;
    }

    // KnighthawK: rotatable doors - special state for the door when it waits to go back

    // if all the way up, just delay before coming down

    if( ent->moverState == MOVER_POS2 && ent->wait == -1 ) {
        // start moving 50 msec later, becase if this was player
        // triggered, level.time hasn't been advanced yet
        MatchTeam( ent, MOVER_2TO1, level.time + 50 );

        // starting sound
        if ( ent->sound2to1 ) {
            if ( ent->elevator_index >= 0)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
            else if ( other->client && other->client->ps.stats[STAT_STEALTH] < 4)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
        }

        // looping sound
        ent->s.loopSound = ent->soundLoop;

        // open areaportal
        if ( ent->teammaster == ent || !ent->teammaster ) {
            trap_AdjustAreaPortalState( ent, qtrue );
        }
        return;
    } else if ( ent->moverState == MOVER_POS2 && ent->wait != -1 ) { // this is for making the door stay up
        ent->nextthink = level.time + ent->wait;
        return;
    }
    // KnighthawK.
    // only partway down before reversing
    if ( ent->moverState == MOVER_2TO1 )
    {
        // KnighthawK: rotatable doors
        if( ! strcmp(ent->classname , "func_door_rotate" ) )
            total = ent->s.apos.trDuration;
        else
            // KnighthawK.
            total = ent->s.pos.trDuration;

        partial = level.time - ent->s.time;

        if ( partial > total )
            partial = total;

        if( !(ent->flags & FL_OPENDOOR )) // KnighthawK: rotatable doors
            MatchTeam( ent, MOVER_1TO2, level.time - ( total - partial ) );
        else
            SetMoverState(ent, MOVER_1TO2, level.time - ( total - partial ) );

        if ( ent->sound1to2 ) {
            if ( ent->elevator_index >= 0)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2 );
            else if ( other->client && other->client->ps.stats[STAT_STEALTH] < 4)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2 );
        }
        return;
    }

    // only partway up before reversing
    if ( ent->moverState == MOVER_1TO2 ) {
        // KnighthawK: rotatable doors
        if( !strcmp ( ent->classname , "func_door_rotate" ) )
            total = ent->s.apos.trDuration;
        else
            total = ent->s.pos.trDuration;
        // KnighthawK.
        partial = level.time - ent->s.time;
        if ( partial > total ) {
            partial = total;
        }

        if( !(ent->flags & FL_OPENDOOR )) // KnighthawK: rotatable doors
            MatchTeam( ent, MOVER_2TO1, level.time - ( total - partial ) );
        else
            SetMoverState(ent, MOVER_2TO1, level.time - ( total - partial ) );

        if ( ent->sound2to1 ) {
            if ( ent->elevator_index >= 0)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
            else if ( other->client && other->client->ps.stats[STAT_STEALTH] < 4)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
        }
        return;
    }
}


// KnighthawK: rotatable doors - pos2 fix
/*
================
Use_BinaryMover2
================
*/
void Use_BinaryMover2( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
    // only the master should be used
    if ( ent->flags & FL_TEAMSLAVE ) {
        Use_BinaryMover( ent->teammaster, other, activator );
        return;
    }

    ent->activator = activator;

    // special state for the door when it waits to go back
    // if all the way up, just delay before coming down
    if( ent->moverState == MOVER_POS2 )
    {
        // start moving 50 msec later, becase if this was player
        // triggered, level.time hasn't been advanced yet
        MatchTeam( ent, MOVER_2TO1, level.time + 50 );
        // starting sound
        if ( ent->sound2to1 ) {
            if ( other->client && other->client->ps.stats[STAT_STEALTH] < 4)
                G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound2to1 );
        }

        // looping sound
        ent->s.loopSound = ent->soundLoop;

        // close areaportal
        if ( ent->teammaster == ent || !ent->teammaster ) {
            trap_AdjustAreaPortalState( ent, qtrue );
        }
        ent->nextthink = -1;
    }
}
// KnighthawK.


/*
================
InitMover

"pos1", "pos2", and "speed" should be set before calling,
so the movement delta can be calculated
================
*/
void InitMover( gentity_t *ent ) {
    vec3_t		move;
    float		distance;
    float		light;
    vec3_t		color;
    qboolean	lightSet, colorSet;
    char		*sound;

    // if the "model2" key is set, use a seperate model
    // for drawing, but clip against the brushes
    if ( ent->model2 ) {
        ent->s.modelindex2 = G_ModelIndex( ent->model2 );
    }

    // if the "loopsound" key is set, use a constant looping sound when moving
    if ( G_SpawnString( "noise", "100", &sound ) ) {
        ent->s.loopSound = G_SoundIndex( sound );
    }

    // if the "color" or "light" keys are set, setup constantLight
    lightSet = G_SpawnFloat( "light", "100", &light );
    colorSet = G_SpawnVector( "color", "1 1 1", color );
    if ( lightSet || colorSet ) {
        int		r, g, b, i;

        r = color[0] * 255;
        if ( r > 255 ) {
            r = 255;
        }
        g = color[1] * 255;
        if ( g > 255 ) {
            g = 255;
        }
        b = color[2] * 255;
        if ( b > 255 ) {
            b = 255;
        }
        i = light / 4;
        if ( i > 255 ) {
            i = 255;
        }
        ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
    }


    ent->use = Use_BinaryMover;
    ent->reached = Reached_BinaryMover;

    ent->moverState = MOVER_POS1;
    ent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
    ent->s.eType = ET_MOVER;

    VectorCopy (ent->pos1, ent->r.currentOrigin);
    trap_LinkEntity (ent);

    ent->s.pos.trType = TR_STATIONARY;
    VectorCopy( ent->pos1, ent->s.pos.trBase );

    // calculate time to reach second position from speed
    VectorSubtract( ent->pos2, ent->pos1, move );
    distance = VectorLength( move );
    if ( ! ent->speed ) {
        ent->speed = 100;
    }
    VectorScale( move, ent->speed, ent->s.pos.trDelta );
    ent->s.pos.trDuration = distance * 1000 / ent->speed;
    if ( ent->s.pos.trDuration <= 0 ) {
        ent->s.pos.trDuration = 1;
    }
    // KnighthawK: rotating door stuff
    if( ent->flags & FL_ROTATE ) {
        VectorCopy( ent->s.angles, ent->s.apos.trBase );
        VectorSubtract( ent->s.angles2, ent->s.angles, move );
        distance = VectorLength( move );
        if ( ! ent->speed ) {
            ent->speed = 100;
        }
        VectorScale( move, ent->speed, ent->s.apos.trDelta );
        ent->s.apos.trDuration = distance * 1000 / ent->speed;
        if( ent->s.apos.trDuration <= 0 ) {
            ent->s.apos.trDuration = 1;
        }
    }

    ent->moverent = G_Spawn();
    ent->moverent->r.svFlags |= SVF_NOCLIENT;
    // KnighthawK.
}


/*
===============================================================================

DOOR

A use can be triggered either by a touch function, by being shot, or by being
targeted by another entity.

===============================================================================
*/

/*
================
Blocked_Door
================
*/
void Blocked_Door( gentity_t *ent, gentity_t *other ) {
    gentity_t	*part ;

    if ( ent->moverState == MOVER_1TO2 )
        ent->moverState = MOVER_STOP_1TO2;
    else if ( ent->moverState == MOVER_2TO1 )
        ent->moverState = MOVER_STOP_2TO1;

    for (part = ent ; part ; part=part->teamchain) {
        BG_EvaluateTrajectory( &part->s.pos, level.time,  part->r.currentOrigin );
        BG_EvaluateTrajectory( &part->s.apos, level.time,  part->r.currentAngles );

        VectorCopy( part->r.currentOrigin , part->s.pos.trBase );
        VectorCopy( part->r.currentAngles , part->s.apos.trBase );

        part->s.pos.trType = TR_INTERPOLATE;
        part->s.pos.trTime = level.time;
        part->s.apos.trType = TR_INTERPOLATE;
        part->s.apos.trTime  = level.time;
    }
}

/*
================
Touch_DoorTriggerSpectator
================
*/

static void Touch_DoorTriggerSpectator( gentity_t *ent, gentity_t *other, trace_t *trace ) {
    int i, axis;
    vec3_t origin, dir, angles;

    axis = ent->count;
    if ( !Is_Spectator(other ) )
        return;

    VectorClear(dir);
    if (fabs(other->s.origin[axis] - ent->r.absmax[axis]) <
            fabs(other->s.origin[axis] - ent->r.absmin[axis])) {
        origin[axis] = ent->r.absmin[axis] - 10;
        dir[axis] = -1;
    }
    else {
        origin[axis] = ent->r.absmax[axis] + 10;
        dir[axis] = 1;
    }
    for (i = 0; i < 3; i++) {
        if (i == axis) continue;
        origin[i] = (ent->r.absmin[i] + ent->r.absmax[i]) * 0.5;
    }
    vectoangles(dir, angles);
    TeleportPlayer(other, origin, angles );
}


/*
==================
Reset a door in the beginning of a round.
==================
*/
void Door_ResetState( gentity_t *door )
{
    if ( door->moverState == MOVER_POS2 ) {
        Use_BinaryMover2(door, door, door );
    } else if ( door->moverState == MOVER_POS1 ) {
        // closed do nothing
    } else if ( door->moverState == MOVER_STOP_1TO2 ||
                door->moverState == MOVER_STOP_2TO1 )
    {
        // we're moving from closed to open but stopped
        if ( door->moverState == MOVER_STOP_1TO2 )
            door->moverState = MOVER_STOP_2TO1; // so set state to open->close

        // close door
        Use_BinaryMover( door, door, door );
    }

}

/*
================
Touch_DoorTrigger
================
*/
void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace )
{

    if( !other->client )
        return;
    // only open if use button ise pressed
    if ( !(other->client->buttons & BUTTON_USE ) )
        return;
    if ( other->client->buttons & BUTTON_USE && !(other->client->oldbuttons & BUTTON_USE) )
        NS_PlayerAnimation( other, TORSO_OPEN_DOOR, 750, qfalse );

    if ( Is_Spectator( other ) && other->client )
    {
        Touch_DoorTriggerSpectator( ent, other, trace );
        return;
    }
    // if client and spectator
    if ( other->client && Is_Spectator(other) )
    {	// if the door is not open and not opening
        Touch_DoorTriggerSpectator( ent, other, trace );
    } else if ( ent->parent->moverState == MOVER_POS2 ) {
        Use_BinaryMover2( ent->parent, ent, other );
    } else if ( ent->parent->moverState == MOVER_POS1 ) {
        Use_BinaryMover( ent->parent, ent, other );
    } else if ( ent->parent->moverState == MOVER_STOP_1TO2 || ent->parent->moverState == MOVER_STOP_2TO1 ) {
        Use_BinaryMover( ent->parent, ent, other );
    }
}

/*
======================
Think_SpawnNewDoorTrigger

All of the parts of a door have been spawned, so create
a trigger that encloses all of them
======================
*/
void Think_SpawnNewDoorTrigger( gentity_t *ent ) {
    gentity_t		*other;
    vec3_t		mins, maxs;
    int			i, best;

    // set all of the slaves as shootable
    for ( other = ent ; other ; other = other->teamchain ) {
        other->takedamage = qtrue;
    }

    // find the bounds of everything on the team
    VectorCopy (ent->r.absmin, mins);
    VectorCopy (ent->r.absmax, maxs);

    for (other = ent->teamchain ; other ; other=other->teamchain) {
        AddPointToBounds (other->r.absmin, mins, maxs);
        AddPointToBounds (other->r.absmax, mins, maxs);
    }

    // find the thinnest axis, which will be the one we expand
    best = 0;
    for ( i = 1 ; i < 3 ; i++ ) {
        if ( maxs[i] - mins[i] < maxs[best] - mins[best] ) {
            best = i;
        }
    }
    for ( i=0;i<2;i++)
    {
        maxs[i] += 10;
        mins[i] -= 10;
    }
    maxs[best] += 30;
    mins[best] -= 30;

    // create a trigger with this size
    other = G_Spawn ();
    VectorCopy (mins, other->r.mins);
    VectorCopy (maxs, other->r.maxs);
    other->parent = ent;
    other->classname = "door_trigger";
    other->r.contents = CONTENTS_TRIGGER;
    other->touch = Touch_DoorTrigger;
    // remember the thinnest axis
    other->count = best;
    trap_LinkEntity (other);

    MatchTeam( ent, ent->moverState, level.time );
}

void Think_MatchTeam( gentity_t *ent ) {
    MatchTeam( ent, ent->moverState, level.time );
}



/*QUAKED func_door_rotate (0 .5 .8) ? X Y Z
TOGGLE		wait in both the start and end states for a trigger event.
START_OPEN	the door to moves to its destination when spawned, and operate in reverse.  It is used to temporarily or permanently close off an area when triggered (not useful for touch or takedamage doors).
NOMONSTER	monsters will not trigger this door

"model2"	.md3 model to also draw
"angle"		determines the opening direction
"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
"speed"		movement speed (100 default)
"wait"		wait before returning (3 default, -1 = never return)
"dmg"		damage to inflict when blocked (2 default)
"color"		constantLight color
"light"		constantLight radius
"health"	if set, the door must be shot open
*/
void SP_func_door_rotate (gentity_t *ent) {
    VectorClear( ent->s.angles );
    VectorCopy( ent->s.angles, ent->s.angles2);

    // default angle to 90 degrees
    G_SpawnFloat( "angle", "0", &ent->angle	);

    G_SpawnInt("elevator_index", "-1", &ent->elevator_index);

    if( !ent->angle )
        ent->angle = 90;

    ent->flags |= FL_OPENDOOR;
    ent->flags |= FL_ROTATE;

    // set the axis of rotation
    VectorClear(ent->movedir);
    if (ent->spawnflags & 1) {			// X AXIS
        ent->movedir[2] = 1.0;
        ent->s.angles2[2] += ent->angle;
    } else if (ent->spawnflags & 2) {	// Y AXIS
        ent->movedir[0] = 1.0;
        ent->s.angles2[0] += ent->angle;
    } else {							// Z AXIS
        ent->movedir[1] = 1.0;
        ent->s.angles2[1] += ent->angle;
    }

    ent->pain_debounce_time = qfalse;

    // moving sounds
    // reached position sounds
    ent->sound1to2 = G_SoundIndex("sound/movers/doors/wooddoor_o.wav");
    ent->soundPos1 = G_SoundIndex("sound/movers/doors/wooddoor_c.wav");

    ent->blocked = Blocked_Door;

    // default damage of 0 points
    G_SpawnInt( "dmg", "0", &ent->damage );

    // default speed of 100
    G_SpawnFloat( "speed", "0", &ent->speed );
    if (!ent->speed)
        ent->speed = 100;

    // default wait of -1 second, which is forever.
    G_SpawnFloat( "wait", "-1", &ent->wait );
    if (!ent->wait)
        ent->wait = -1;
    if ( ent->wait > 0 )
        ent->wait *= 1000;
    ent->classname = "func_door_rotate";

    // We'll just set pos1 and 2 to its origin, as it wont be moving
    VectorCopy( ent->s.origin, ent->pos1 );
    VectorCopy( ent->pos1, ent->pos2 );

    // calculate second position
    trap_SetBrushModel( ent, ent->model );

    // if the door should start open, reverse pos1 and pos2
    if ( ent->spawnflags & 4 ) {
        vec3_t	temp;

        VectorCopy( ent->pos2, temp );
        VectorCopy( ent->s.origin, ent->pos2 );
        VectorCopy( temp, ent->pos1 );

        VectorCopy( ent->s.angles2, temp );
        VectorCopy( ent->s.angles, ent->s.angles2 );
        VectorCopy( temp, ent->s.angles );

    }

    InitMover( ent );

    ent->nextthink = level.time + FRAMETIME;

    if ( ! (ent->flags & FL_TEAMSLAVE ) ) {
        G_SpawnInt( "health", "0", &ent->health );
        if ( ent->health ) {
            ent->takedamage = qtrue;
        }
        if ( ent->targetname || ent->health ) {
            // non touch/shoot doors
            ent->think = Think_MatchTeam;
        } else {
            ent->think = Think_SpawnNewDoorTrigger;
            ent->s.eType = ET_DOOR;
        }
    }
}

/*QUAKED func_door (0 .5 .8) ? START_OPEN x CRUSHER
TOGGLE		wait in both the start and end states for a trigger event.
START_OPEN	the door to moves to its destination when spawned, and operate in reverse.  It is used to temporarily or permanently close off an area when triggered (not useful for touch or takedamage doors).
NOMONSTER	monsters will not trigger this door

"model2"	.md3 model to also draw
"angle"		determines the opening direction
"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
"speed"		movement speed (100 default)
"wait"		wait before returning (3 default, -1 = never return)
"lip"		lip remaining at end of move (8 default)
"dmg"		damage to inflict when blocked (2 default)
"color"		constantLight color
"light"		constantLight radius
"health"	if set, the door must be shot open
*/
void SP_func_door (gentity_t *ent) {
    vec3_t	abs_movedir;
    float	distance;
    vec3_t	size;
    float	lip;

    // additional elevator support
    G_SpawnInt("elevator_index", "-1", &ent->elevator_index);

    if (ent->elevator_index < 0) {
        ent->sound1to2 = G_SoundIndex("sound/movers/doors/dr1_strt.wav");
        ent->soundPos1 = G_SoundIndex("sound/movers/doors/dr1_end.wav");
    } else {
        ent->sound1to2 = ent->sound2to1 = G_SoundIndex("sound/movers/doors/elevdoor.wav");
    }

    ent->blocked = Blocked_Door;

    // default speed of 400
    if (!ent->speed)
        ent->speed = 400;

    // default wait of 2 seconds
    if (!ent->wait)
        ent->wait = 2;
    if (ent->wait != -1)
        ent->wait *= 1000;

    // default lip of 8 units
    G_SpawnFloat( "lip", "8", &lip );

    // default damage of 2 points
    G_SpawnInt( "dmg", "2", &ent->damage );

    // first position at start
    VectorCopy( ent->s.origin, ent->pos1 );

    // calculate second position
    trap_SetBrushModel( ent, ent->model );
    G_SetMovedir (ent->s.angles, ent->movedir);
    abs_movedir[0] = fabs(ent->movedir[0]);
    abs_movedir[1] = fabs(ent->movedir[1]);
    abs_movedir[2] = fabs(ent->movedir[2]);
    VectorSubtract( ent->r.maxs, ent->r.mins, size );
    distance = DotProduct( abs_movedir, size ) - lip;
    VectorMA( ent->pos1, distance, ent->movedir, ent->pos2 );

    // if "start_open", reverse position 1 and 2
    if ( ent->spawnflags & 1 ) {
        vec3_t	temp;

        VectorCopy( ent->pos2, temp );
        VectorCopy( ent->s.origin, ent->pos2 );
        VectorCopy( temp, ent->pos1 );
        // indicate open
        ent->bot_chattime = 1;
    } else {
        ent->bot_chattime = 0;
    }

    InitMover( ent );

    if ( ! (ent->flags & FL_TEAMSLAVE ) ) {
        int health;

        G_SpawnInt( "health", "0", &health );
        if ( health ) {
            ent->takedamage = qtrue;
        }
        if ( ent->targetname || health ) {
            // non touch/shoot doors
            ent->think = Think_MatchTeam;
        }// 7-12-2000
        else { // i decided to keep this doortrigger so bots are able to open them...
            ent->think = Think_SpawnNewDoorTrigger;
            ent->s.eType = ET_DOOR;
        }
    }

    // 7-12-2000
    if (ent->think)
        ent->nextthink = level.time + FRAMETIME;
    // end
}

/*
===============================================================================

PLAT

===============================================================================
*/

/*
==============
Touch_Plat

Don't allow decent if a living player is on it
===============
*/
void Touch_Plat( gentity_t *ent, gentity_t *other, trace_t *trace ) {
    if ( !other->client || other->client->ps.stats[STAT_HEALTH] <= 0 ) {
        return;
    }

    // delay return-to-pos1 by one second
    if ( ent->moverState == MOVER_POS2 ) {
        ent->nextthink = level.time + 1000;
    }
}

/*
==============
Touch_PlatCenterTrigger

If the plat is at the bottom position, start it going up
===============
*/
void Touch_PlatCenterTrigger(gentity_t *ent, gentity_t *other, trace_t *trace ) {
    if ( !other->client ) {
        return;
    }

    if ( ent->parent->moverState == MOVER_POS1 ) {
        Use_BinaryMover( ent->parent, ent, other );
    }
}


/*
================
SpawnPlatTrigger

Spawn a trigger in the middle of the plat's low position
Elevator cars require that the trigger extend through the entire low position,
not just sit on top of it.
================
*/
void SpawnPlatTrigger( gentity_t *ent ) {
    gentity_t	*trigger;
    vec3_t	tmin, tmax;

    // the middle trigger will be a thin trigger just
    // above the starting position
    trigger = G_Spawn();
    trigger->touch = Touch_PlatCenterTrigger;
    trigger->r.contents = CONTENTS_TRIGGER;
    trigger->parent = ent;

    tmin[0] = ent->pos1[0] + ent->r.mins[0] + 33;
    tmin[1] = ent->pos1[1] + ent->r.mins[1] + 33;
    tmin[2] = ent->pos1[2] + ent->r.mins[2];

    tmax[0] = ent->pos1[0] + ent->r.maxs[0] - 33;
    tmax[1] = ent->pos1[1] + ent->r.maxs[1] - 33;
    tmax[2] = ent->pos1[2] + ent->r.maxs[2] + 8;

    if ( tmax[0] <= tmin[0] ) {
        tmin[0] = ent->pos1[0] + (ent->r.mins[0] + ent->r.maxs[0]) *0.5;
        tmax[0] = tmin[0] + 1;
    }
    if ( tmax[1] <= tmin[1] ) {
        tmin[1] = ent->pos1[1] + (ent->r.mins[1] + ent->r.maxs[1]) *0.5;
        tmax[1] = tmin[1] + 1;
    }

    VectorCopy (tmin, trigger->r.mins);
    VectorCopy (tmax, trigger->r.maxs);

    trap_LinkEntity (trigger);
}


/*QUAKED func_plat (0 .5 .8) ?
Plats are always drawn in the extended position so they will light correctly.

"lip"		default 8, protrusion above rest position
"height"	total height of movement, defaults to model height
"speed"		overrides default 200.
"dmg"		overrides default 2
"model2"	.md3 model to also draw
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_plat (gentity_t *ent) {
    float		lip, height;

    ent->sound1to2 = ent->sound2to1 = G_SoundIndex("sound/movers/plats/pt1_strt.wav");
    ent->soundPos1 = ent->soundPos2 = G_SoundIndex("sound/movers/plats/pt1_end.wav");

    VectorClear (ent->s.angles);

    G_SpawnFloat( "speed", "200", &ent->speed );
    G_SpawnInt( "dmg", "2", &ent->damage );
    G_SpawnFloat( "wait", "1", &ent->wait );
    G_SpawnFloat( "lip", "8", &lip );

    ent->wait = 1000;

    // create second position
    trap_SetBrushModel( ent, ent->model );

    if ( !G_SpawnFloat( "height", "0", &height ) ) {
        height = (ent->r.maxs[2] - ent->r.mins[2]) - lip;
    }

    // pos1 is the rest (bottom) position, pos2 is the top
    VectorCopy( ent->s.origin, ent->pos2 );
    VectorCopy( ent->pos2, ent->pos1 );
    ent->pos1[2] -= height;

    InitMover( ent );

    // touch function keeps the plat from returning while
    // a live player is standing on it
    ent->touch = Touch_Plat;

    ent->blocked = Blocked_Door;

    ent->parent = ent;	// so it can be treated as a door

    // spawn the trigger if one hasn't been custom made
    if ( !ent->targetname ) {
        SpawnPlatTrigger(ent);
    }
}


/*
===============================================================================

BUTTON

===============================================================================
*/

/*
==============
Touch_Button

===============
*/
void Touch_Button(gentity_t *ent, gentity_t *other, trace_t *trace ) {
    if ( !other->client ) {
        return;
    }
    // if game is open
    if (GameState == STATE_OPEN && g_gametype.integer == GT_LTS)
        return;

    // e 2 - means free
    if (ent->ns_team != 2 && !Is_OnBrushTeam(ent,other) )
        return;

    if ( other->client && !( other->client->buttons & BUTTON_USE ) )
        return;

    if ( ent->moverState == MOVER_POS1 ) {
        Use_BinaryMover( ent, other, other );
    }

    G_UseTargets( ent, NULL);
}


/*QUAKED func_button (0 .5 .8) ?
When a button is touched, it moves some distance in the direction of it's angle, triggers all of it's targets, waits some time, then returns to it's original position where it can be triggered again.

"model2"	.md3 model to also draw
"angle"		determines the opening direction
"target"	all entities with a matching targetname will be used
"speed"		override the default 40 speed
"wait"		override the default 1 second wait (-1 = never return)
"lip"		override the default 4 pixel lip remaining at end of move
"health"	if set, the button must be killed instead of touched
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_button( gentity_t *ent ) {
    vec3_t		abs_movedir;
    float		distance;
    vec3_t		size;
    float		lip;
    int bla;

    G_SpawnInt("team","2", &ent->ns_team);
    G_SpawnInt("elevator_index", "0", &bla);
    ent->elevator_index = bla;

    //	ent->sound1to2 = G_SoundIndex("sound/movers/switches/butn2.wav");

    if ( !ent->speed ) {
        ent->speed = 40;
    }

    if ( !ent->wait ) {
        ent->wait = 1;
    }
    ent->wait *= 1000;

    //first position
    VectorCopy( ent->s.origin, ent->pos1 );

    // calculate second position
    trap_SetBrushModel( ent, ent->model );

    G_SpawnFloat( "lip", "4", &lip );
    G_SetMovedir( ent->s.angles, ent->movedir );
    abs_movedir[0] = fabs(ent->movedir[0]);
    abs_movedir[1] = fabs(ent->movedir[1]);
    abs_movedir[2] = fabs(ent->movedir[2]);
    VectorSubtract( ent->r.maxs, ent->r.mins, size );
    distance = abs_movedir[0] * size[0] + abs_movedir[1] * size[1] + abs_movedir[2] * size[2] - lip;
    VectorMA (ent->pos1, distance, ent->movedir, ent->pos2);

    if (ent->health) {
        // shootable button
        ent->takedamage = qtrue;
    } else {
        // touchable button
        ent->touch = Touch_Button;
    }

    InitMover( ent );
}



/*
===============================================================================

TRAIN

===============================================================================
*/


#define TRAIN_START_ON		1
#define TRAIN_TOGGLE		2
#define TRAIN_BLOCK_STOPS	4

/*
===============
Think_BeginMoving

The wait time at a corner has completed, so start moving again
===============
*/
void Think_BeginMoving( gentity_t *ent ) {
    ent->s.pos.trTime = level.time;
    ent->s.pos.trType = TR_LINEAR_STOP;
}

/*
===============
Reached_Train
===============
*/
void Reached_Train( gentity_t *ent ) {
    gentity_t		*next;
    float			speed;
    vec3_t			move;
    float			length;

    // copy the apropriate values
    next = ent->nextTrain;
    if ( !next || !next->nextTrain ) {
        return;		// just stop
    }

    // fire all other targets
    G_UseTargets( next, NULL );

    // set the new trajectory
    ent->nextTrain = next->nextTrain;
    VectorCopy( next->s.origin, ent->pos1 );
    VectorCopy( next->nextTrain->s.origin, ent->pos2 );

    // if the path_corner has a speed, use that
    if ( next->speed ) {
        speed = next->speed;
    } else {
        // otherwise use the train's speed
        speed = ent->speed;
    }
    if ( speed < 1 ) {
        speed = 1;
    }

    // calculate duration

    VectorSubtract( ent->pos2, ent->pos1, move );
    length = VectorLength( move );

    ent->s.pos.trDuration = length * 1000 / speed;

    // looping sound
    ent->s.loopSound = next->soundLoop;

    // start it going
    SetMoverState( ent, MOVER_1TO2, level.time );

    // if there is a "wait" value on the target, don't start moving yet
    if ( next->wait ) {
        ent->nextthink = level.time + next->wait * 1000;
        ent->think = Think_BeginMoving;
        ent->s.pos.trType = TR_STATIONARY;
    }
}


/*
===============
Think_SetupTrainTargets

Link all the corners together
===============
*/
void Think_SetupTrainTargets( gentity_t *ent ) {
    gentity_t		*path, *next, *start;

    ent->nextTrain = G_Find( NULL, FOFS(targetname), ent->target );
    if ( !ent->nextTrain ) {
        G_Printf( "func_train at %s with an unfound target\n",
                  vtos(ent->r.absmin) );
        return;
    }

    start = NULL;
    for ( path = ent->nextTrain ; path != start ; path = next ) {
        if ( !start ) {
            start = path;
        }

        if ( !path->target ) {
            G_Printf( "Train corner at %s without a target\n",
                      vtos(path->s.origin) );
            return;
        }

        // find a path_corner among the targets
        // there may also be other targets that get fired when the corner
        // is reached
        next = NULL;
        do {
            next = G_Find( next, FOFS(targetname), path->target );
            if ( !next ) {
                G_Printf( "Train corner at %s without a target path_corner\n",
                          vtos(path->s.origin) );
                return;
            }
        } while ( strcmp( next->classname, "path_corner" ) );

        path->nextTrain = next;
    }

    // start the train moving from the first corner
    Reached_Train( ent );
}



/*QUAKED path_corner (.5 .3 0) (-8 -8 -8) (8 8 8)
Train path corners.
Target: next path corner and other targets to fire
"speed" speed to move to the next corner
"wait" seconds to wait before behining move to next corner
*/
void SP_path_corner( gentity_t *self ) {
    if ( !self->targetname ) {
        G_Printf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
        G_FreeEntity( self );
        return;
    }
    // path corners don't need to be linked in
}



/*QUAKED func_train (0 .5 .8) ? START_ON TOGGLE BLOCK_STOPS
A train is a mover that moves between path_corner target points.
Trains MUST HAVE AN ORIGIN BRUSH.
The train spawns at the first target it is pointing at.
"model2"	.md3 model to also draw
"speed"		default 100
"dmg"		default	2
"noise"		looping sound to play when the train is in motion
"target"	next path corner
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_train (gentity_t *self) {
    VectorClear (self->s.angles);

    if (self->spawnflags & TRAIN_BLOCK_STOPS) {
        self->damage = 0;
    } else {
        if (!self->damage) {
            self->damage = 2;
        }
    }

    if ( !self->speed ) {
        self->speed = 100;
    }

    if ( !self->target ) {
        G_Printf ("func_train without a target at %s\n", vtos(self->r.absmin));
        G_FreeEntity( self );
        return;
    }

    trap_SetBrushModel( self, self->model );
    InitMover( self );

    self->reached = Reached_Train;

    // start trains on the second frame, to make sure their targets have had
    // a chance to spawn
    self->nextthink = level.time + FRAMETIME;
    self->think = Think_SetupTrainTargets;
}

/*
===============================================================================

STATIC

===============================================================================
*/


/*QUAKED func_static (0 .5 .8) ?
A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
"model2"	.md3 model to also draw
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_static( gentity_t *ent ) {
    trap_SetBrushModel( ent, ent->model );
    InitMover( ent );
    VectorCopy( ent->s.origin, ent->s.pos.trBase );
    VectorCopy( ent->s.origin, ent->r.currentOrigin );
}


/*
===============================================================================

ROTATING

===============================================================================
*/


/*QUAKED func_rotating (0 .5 .8) ? START_ON - X_AXIS Y_AXIS
You need to have an origin brush as part of this entity.  The center of that brush will be
the point around which it is rotated. It will rotate around the Z axis by default.  You can
check either the X_AXIS or Y_AXIS box to change that.

"model2"	.md3 model to also draw
"speed"		determines how fast it moves; default value is 100.
"dmg"		damage to inflict when blocked (2 default)
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_rotating (gentity_t *ent) {
    if ( !ent->speed ) {
        ent->speed = 100;
    }

    // set the axis of rotation
    ent->s.apos.trType = TR_LINEAR;
    if ( ent->spawnflags & 4 ) {
        ent->s.apos.trDelta[2] = ent->speed;
    } else if ( ent->spawnflags & 8 ) {
        ent->s.apos.trDelta[0] = ent->speed;
    } else {
        ent->s.apos.trDelta[1] = ent->speed;
    }

    if (!ent->damage) {
        ent->damage = 2;
    }

    trap_SetBrushModel( ent, ent->model );
    InitMover( ent );

    VectorCopy( ent->s.origin, ent->s.pos.trBase );
    VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
    VectorCopy( ent->s.apos.trBase, ent->r.currentAngles );

    trap_LinkEntity( ent );
}


/*
===============================================================================

BOBBING

===============================================================================
*/


/*QUAKED func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS
Normally bobs on the Z axis
"model2"	.md3 model to also draw
"height"	amplitude of bob (32 default)
"speed"		seconds to complete a bob cycle (4 default)
"phase"		the 0.0 to 1.0 offset in the cycle to start at
"dmg"		damage to inflict when blocked (2 default)
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_bobbing (gentity_t *ent) {
    float		height;
    float		phase;

    G_SpawnFloat( "speed", "4", &ent->speed );
    G_SpawnFloat( "height", "32", &height );
    G_SpawnInt( "dmg", "2", &ent->damage );
    G_SpawnFloat( "phase", "0", &phase );

    trap_SetBrushModel( ent, ent->model );
    InitMover( ent );

    VectorCopy( ent->s.origin, ent->s.pos.trBase );
    VectorCopy( ent->s.origin, ent->r.currentOrigin );

    ent->s.pos.trDuration = ent->speed * 1000;
    ent->s.pos.trTime = ent->s.pos.trDuration * phase;
    ent->s.pos.trType = TR_SINE;

    // set the axis of bobbing
    if ( ent->spawnflags & 1 ) {
        ent->s.pos.trDelta[0] = height;
    } else if ( ent->spawnflags & 2 ) {
        ent->s.pos.trDelta[1] = height;
    } else {
        ent->s.pos.trDelta[2] = height;
    }
}

/*
===============================================================================

PENDULUM

===============================================================================
*/


/*QUAKED func_pendulum (0 .5 .8) ?
You need to have an origin brush as part of this entity.
Pendulums always swing north / south on unrotated models.  Add an angles field to the model to allow rotation in other directions.
Pendulum frequency is a physical constant based on the length of the beam and gravity.
"model2"	.md3 model to also draw
"speed"		the number of degrees each way the pendulum swings, (30 default)
"phase"		the 0.0 to 1.0 offset in the cycle to start at
"dmg"		damage to inflict when blocked (2 default)
"color"		constantLight color
"light"		constantLight radius
*/
void SP_func_pendulum(gentity_t *ent) {
    float		freq;
    float		length;
    float		phase;
    float		speed;

    G_SpawnFloat( "speed", "30", &speed );
    G_SpawnInt( "dmg", "2", &ent->damage );
    G_SpawnFloat( "phase", "0", &phase );

    trap_SetBrushModel( ent, ent->model );

    // find pendulum length
    length = fabs( ent->r.mins[2] );
    if ( length < 8 ) {
        length = 8;
    }

    freq = 1 / ( M_PI * 2 ) * sqrt( g_gravity.value / ( 3 * length ) );

    ent->s.pos.trDuration = ( 1000 / freq );

    InitMover( ent );

    VectorCopy( ent->s.origin, ent->s.pos.trBase );
    VectorCopy( ent->s.origin, ent->r.currentOrigin );

    VectorCopy( ent->s.angles, ent->s.apos.trBase );

    ent->s.apos.trDuration = 1000 / freq;
    ent->s.apos.trTime = ent->s.apos.trDuration * phase;
    ent->s.apos.trType = TR_SINE;
    ent->s.apos.trDelta[2] = speed;
}

/*QUAKED func_ammo_train (0 .5 .8) ? START_ON TOGGLE BLOCK_STOPS
When the ammotrain is destroyed, the opposite team wins.
if the "team" flag is "1" (tangos) then the "0" (seals) win...
A train is a mover that moves between path_corner target points.
Trains MUST HAVE AN ORIGIN BRUSH.
The train spawns at the first target it is pointing at.
"model2"	.md3 model to also draw
"speed"		default 100
"dmg"		default	2
"noise"		looping sound to play when the train is in motion
"target"	next path corner
"color"		constantLight color
"light"		constantLight radius
"team"		the team it belongs to (0 seals 1 tangos) [must set]
"health"	default 100
*/
void AmmoTrain_Die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
{
    G_Printf("ammo train is dead");

    // don't move anymore
    self->nextthink = 0;
    self->speed = 0;
}

void SP_func_ammo_train (gentity_t *self) {
    G_SpawnInt( "team", "0", &self->ns_team);
    G_SpawnInt("health", "500", &self->health );

    VectorClear (self->s.angles);


    // guess what, it does big damage when nothing set
    if (!self->damage) {
        self->damage = 50;
    }

    // backup speed, since the train should not move when the round didn't start
    self->count = self->speed;
    // backup health
    self->splashDamage  = self->health;

    if ( !self->target ) {
        G_Printf ("func_ammo_train without a target at %s\n", vtos(self->r.absmin));
        G_FreeEntity( self );
        return;
    }

    trap_SetBrushModel( self, self->model );
    InitMover( self );


    self->takedamage = qtrue;

    self->reached = Reached_Train;

    // start trains on the second frame, to make sure their targets have had
    // a chance to spawn
    self->nextthink = level.time + FRAMETIME;
    self->think = Think_SetupTrainTargets;
    self->die = AmmoTrain_Die;
}

/*QUAKED func_elevator (0 .5 .8)
The elevator! It only moves along the z-axxis!

"model2"	   .md3 model to also draw
"speed"		    default 100
"dmg"		      default	999
"targetname"  the targetname of the elevator (for triggers)
"target"      points to path_elevators
*/

/*
===============
Reached_Elevator
===============
*/
void Reached_Elevator( gentity_t *ent ) {
    gentity_t *t;

    // stop the looping sound
    ent->s.loopSound = 0;

    if ( ent->moverState == MOVER_1TO2) {

        // play sound
        if ( ent->soundPos2 )	G_AddEvent( ent, EV_GENERAL_SOUND, ent->soundPos2 );

        // fire targets
        if ( !ent->activator ) {
            ent->activator = ent;
        }

        VectorCopy(ent->pos2, ent->pos1);

        t = NULL;
        // look through all func_doors
        while ( (t = G_Find(t, FOFS(targetname), ent->target)) != NULL ) {
            // if we find it, check if it's the correct door (depends on level)
            // and if it's able to use, use it!
            if ( (ent->elevator_index == t->elevator_index) &&
                    (!strcmp(t->classname, "func_door") ) ) {
                if (t->use) t->use(t, ent, ent->activator);
            }
        }

        // reached pos2
        SetMoverState( ent, MOVER_POS1, level.time + 50 );
    }
}

void Use_Elevator( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
    gentity_t *t;
    gentity_t *s;
    float			speed;
    vec3_t			move;
    float			length;

    if (!other) return;

    ent->activator = activator;

    if ( (ent->moverState == MOVER_POS1 ||
            ent->moverState == MOVER_POS2) ) {
        // loop through the targets and look for the correct
        // path_elevator
        t = NULL;
        while ( (t = G_Find(t, FOFS(targetname), ent->target)) != NULL ) {
            if ( (other->elevator_index == t->elevator_index) &&
                    (!strcmp(t->classname, "path_elevator")) ) break;
        }

        if (t == NULL) {
            G_Printf("Use_Elevator with an unfound target!\n");
            return;
        }

        // always trigger the door on same level (open / close door)
        if (ent->elevator_index == other->elevator_index) {
            s = NULL;
            while ( (s = G_Find(s, FOFS(targetname), ent->target)) != NULL ) {
                if ( (ent->elevator_index == s->elevator_index) &&
                        (!strcmp(s->classname, "func_door")) ) {
                    // we found a door to close
                    Use_BinaryMover(s, ent, activator);
                }
            }
        } else {
            // only trigger door if it's open if we call the elevator from another
            // level
            s = NULL;
            while ( (s = G_Find(s, FOFS(targetname), ent->target)) != NULL ) {
                if ( (ent->elevator_index == s->elevator_index) &&
                        (!strcmp(s->classname, "func_door")) &&
                        (s->moverState == MOVER_POS2)) {
                    // we found a door to close
                    Use_BinaryMover(s, ent, activator);
                }
            }
        }

        // only perform the move operation, if we are moving to a different level
        if (ent->elevator_index != other->elevator_index) {
            // save the index of the level we are going to
            ent->elevator_index = t->elevator_index;

            if ( ent->sound1to2 ) G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2);

            VectorCopy(ent->pos2, ent->pos1);
            VectorCopy(t->s.origin, ent->pos2);

            // if the path_corner has a speed, use that
            if ( t->speed ) {
                speed = t->speed;
            } else {
                // otherwise use the train's speed
                speed = ent->speed;
            }
            if ( speed < 1 ) {
                speed = 1;
            }

            // calculate duration
            VectorSubtract( ent->pos2, ent->pos1, move );
            length = VectorLength( move );
            VectorScale( move, ent->speed, ent->s.pos.trDelta );
            ent->s.pos.trDuration = length * 1000 / ent->speed;
            if ( ent->s.pos.trDuration <= 0 ) {
                ent->s.pos.trDuration = 1;
            }

            ent->s.pos.trDuration = length * 1000 / speed;

            // looping sound
            ent->s.loopSound = ent->soundLoop;

            SetMoverState( ent, MOVER_1TO2, level.time + 50);
        }
    }



}

void Think_Elevator( gentity_t *ent ) {


}

void SP_func_elevator (gentity_t *ent) {
    qboolean lightSet, colorSet;
    float light;
    float distance;
    vec3_t color;
    vec3_t move;

    G_SpawnInt("elevator_index", "0", &ent->elevator_index);

    if (!ent->speed) ent->speed = 100;
    if (!ent->damage) ent->damage = 25;
    // ent->sound1to2 = ent->sound2to1 = G_SoundIndex("sound/movers/doors/elevmove.wav");
    ent->soundLoop = G_SoundIndex("sound/movers/doors/elevmove.wav");
    ent->soundPos1 = ent->soundPos2 = G_SoundIndex("sound/movers/doors/elevding.wav");

    trap_SetBrushModel(ent, ent->model );

    ent->nextthink = level.time + FRAMETIME;
    ent->think = Think_Elevator;

    VectorCopy( ent->s.origin, ent->pos1 );
    VectorCopy( ent->pos1, ent->pos2);

    VectorClear(ent->movedir);
    VectorClear(ent->s.angles2);
    ent->movedir[2] = 1.0;

    if ( ent->model2) ent->s.modelindex2 = G_ModelIndex( ent->model2 );

    lightSet  = G_SpawnFloat( "light", "100", &light);
    colorSet = G_SpawnVector( "color", "1 1 1", color);
    if ( lightSet || colorSet ) {
        int		r, g, b, i;

        r = color[0] * 255;
        if ( r > 255 ) {
            r = 255;
        }
        g = color[1] * 255;
        if ( g > 255 ) {
            g = 255;
        }
        b = color[2] * 255;
        if ( b > 255 ) {
            b = 255;
        }
        i = light / 4;
        if ( i > 255 ) {
            i = 255;
        }
        ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
    }

    ent->use = Use_Elevator;
    ent->reached = Reached_Elevator;

    SetMoverState( ent, MOVER_POS1, level.time + 50);
    ent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
    ent->s.eType = ET_MOVER;

    VectorCopy ( ent->pos1, ent->r.currentOrigin );
    trap_LinkEntity(ent);

    ent->s.pos.trType = TR_STATIONARY;
    VectorCopy( ent->pos1, ent->s.pos.trBase );

    // calculate time to reach second position from speed
    VectorSubtract( ent->pos2, ent->pos1, move );
    distance = VectorLength( move );
    VectorScale( move, ent->speed, ent->s.pos.trDelta );
    ent->s.pos.trDuration = distance * 1000 / ent->speed;
    if ( ent->s.pos.trDuration <= 0 ) {
        ent->s.pos.trDuration = 1;
    }

}

/*QUAKED path_elevator (.5 .3 0) (-8 -8 -8) (8 8 8) LEV0 LEV1 LEV2 LEV3
Elevator level path.
"targetname" the elevator
"speed" speed to move to the next elevator level
*/
void SP_path_elevator( gentity_t *self ) {
    if ( !self->targetname ) {
        G_Printf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
        G_FreeEntity( self );
        return;
    }

    if (self->spawnflags == 1) self->elevator_index = 0;
    if (self->spawnflags == 2) self->elevator_index = 1;
    if (self->spawnflags == 4) self->elevator_index = 2;
    if (self->spawnflags == 8) self->elevator_index = 3;
    if (self->spawnflags == 16) self->elevator_index = 4;
    if (self->spawnflags == 32) self->elevator_index = 5;
    if (self->spawnflags == 64) self->elevator_index = 6;
    if (self->spawnflags == 128) self->elevator_index = 7;
}


void ElevatorReset( gentity_t *ent ) {
    gentity_t *t;
    float			speed;
    vec3_t			move;
    float			length;

    // loop through the targets and look for the correct
    // path_elevator
    t = NULL;
    while ( (t = G_Find(t, FOFS(targetname), ent->target)) != NULL ) {
        if ( (0 == t->elevator_index) &&
                (!strcmp(t->classname, "path_elevator")) ) break;
    }

    if (t == NULL) {
        G_Printf("Use_Elevator with an unfound target!\n");
        return;
    }

    // save the index of the level we are going to
    ent->elevator_index = t->elevator_index;

    if ( ent->sound1to2 ) G_AddEvent( ent, EV_GENERAL_SOUND, ent->sound1to2);

    VectorCopy(ent->pos2, ent->pos1);
    VectorCopy(t->s.origin, ent->pos2);

    // if the path_corner has a speed, use that
    if ( t->speed ) {
        speed = t->speed;
    } else {
        // otherwise use the train's speed
        speed = ent->speed;
    }
    if ( speed < 1 ) {
        speed = 1;
    }

    // calculate duration
    VectorSubtract( ent->pos2, ent->pos1, move );
    length = VectorLength( move );
    VectorScale( move, ent->speed, ent->s.pos.trDelta );
    ent->s.pos.trDuration = length * 1000 / ent->speed;
    if ( ent->s.pos.trDuration <= 0 ) {
        ent->s.pos.trDuration = 1;
    }

    ent->s.pos.trDuration = length * 1000 / speed;

    // looping sound
    ent->s.loopSound = ent->soundLoop;

    SetMoverState( ent, MOVER_1TO2, level.time + 50);
}
